package mysql;

import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import mpo.Database;
import mpo.Dyrektor;
import mpo.Kategoria;
import mpo.Ksiegowa;
import mpo.Pracownik;
import mpo.User;
import mpo.Klient;
import mpo.Premia;
import mpo.Sprzet;
import mpo.StatusZlecenia;
import mpo.Utility;
import mpo.Zespol;
import mpo.Zlecenie;

public class Db_Mysql implements Database {

    private Connection con = null; //dostep RAW do bazy
    private static Db_Mysql db = null; // zapewnia dostep do instancyjnych metod tej klasy

    /**
     * metody dostepowe
     */
    public static Db_Mysql instance() {
        if (db == null) {
            System.out.println("DB: Pierwsze wywolanie, trzeba inicjalizowac");
            Mysql_access.tryGetNewerAccess();
            db = new Db_Mysql(Mysql_access.DB_CONN_STRING,
                    Mysql_access.USER_NAME,
                    Mysql_access.PASSWORD,
                    Mysql_access.DRIVER_CLASS_NAME);
            if (db != null) {
                System.out.println("DB: Dostep gotowy");
            }
        }
        return db;
    }

    public static Db_Mysql forceNewInstance(String url, String login, String password, String driver) {
        System.out.println("Wymuszona nowa instancja z gotowych argumentow");
        db = new Db_Mysql(url, login, password, driver);
        if (db != null) {
            System.out.println("DB: Dostep gotowy");
        }
        return db;
    }
  
    public void closeConDb(){
        
		System.out.print("\nZamykanie polaczenia z baza:");
		try {
			con.close(); // caly connect;
		} catch (SQLException e) {
			System.out.println("Blad przy zamykaniu polaczenia " +e.toString());
			System.exit(4);
		}
                db = null;
		System.out.print("Zamkniecie połączenia ->OK");
    }
    
    /**
     *
     * @return
     */
    @Override
    public boolean isExistDBConfigure(){
        return Mysql_access.isConfigured();
    }

    @Override
    public boolean isConnected(boolean talkative) {
        db = instance();
        try {
            if (talkative) {
                System.out.println(">isConnected: Tryb gadatlivy ");
                System.out.println("Katalog: " + con.getCatalog());
                System.out.println("Poziom izolacji: " + con.getTransactionIsolation());
                System.out.println("Valid?: " + con.isValid(5));
                System.out.println("Czy zamkniete połaczenie:" + con.isClosed());
                System.out.println("<isConnected");
            }
            if (!con.isValid(5)) {
                throw new Exception();
            }
            return true;
        } catch (Exception e) {
            System.err.println("Blad w isConnected / blad z polaczeniem do bazy");
            return false;
        }
    }

    private Db_Mysql(String url, String login, String password, String driver) {
        
        con = ConnectDb(url, login, password, driver);
    }

    private Connection ConnectDb(String db_url, String db_login, String db_password, String driver) {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            con = DriverManager.getConnection(db_url, db_login, db_password);
            return con;
        } catch (SQLException ex)  {
            System.out.println("sqlBlad w ustanawianiu polaczenia");
            System.out.println("Error: " + ex);
            return null;
        }
        catch (Exception ex) {
            System.out.println("Blad w ustanawianiu polaczenia");
            System.out.println("Error: " + ex);
            return null;
        }
    }

    @Override
    public boolean isPeselFree(String pesel) {
        boolean wynik = false;
        try (PreparedStatement pst = con.prepareStatement("select pesel from User where pesel = ?")) {
            pst.setString(1, pesel);
            try (ResultSet rs = pst.executeQuery()) {
                wynik = !rs.first();
            } catch (SQLException e) {
                // Handle the exeption for the result set
            }
        } catch (SQLException e) {
            // Handle the exeption for the prepared statement
        }
        return wynik;
    }

    //////////////////////////////USER
    @Override
    public User getUser(String pesel) {
        boolean isFounded = false;
        String login = "";
        String haslo = "";
        String imie = "";
        String nazwisko = "";
        String NIP = "";
        String telefon = "";
        String adres = "";
        int idZlecenie = 0;

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select * from User where Pesel= ? ");
            pst.setString(1, pesel);
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                isFounded = true;
                //pobieranie po nazwach kolumn
                haslo = rs.getString("haslo");
                login = rs.getString("login");
                imie = rs.getString("imie");
                nazwisko = rs.getString("nazwisko");
                NIP = rs.getString("NIP");
                telefon = rs.getString("telefon");
                adres = rs.getString("adres");
                idZlecenie = rs.getInt("idZlecenie");

            }
        } catch (Exception e) {
            System.err.println(e);
        }

        if (!isFounded) {
            return null;
        }

        User stworzonyUser;
        stworzonyUser = new User(pesel, haslo, login, imie, nazwisko, NIP, telefon, adres, idZlecenie);
        return stworzonyUser;
    }

    @Override
    public List<String> getUsersPeselList() {
        List<String> listaPeseliUsera = new ArrayList<String>();

        String pesel = "";
        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select pesel from User");
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                pesel = rs.getString("pesel");
                listaPeseliUsera.add(pesel);
            }
        } catch (Exception e) {
            System.err.println(e);
        }
        return listaPeseliUsera;
    }

    @Override
    public List<User> getUserList() {
        List<User> userList = new ArrayList<User>();

        List<String> listaPeseliUserow = db.getUsersPeselList();

        for (String peselUseraDoPobrania : listaPeseliUserow) {
            userList.add(getUser(peselUseraDoPobrania));
        }

        return userList;

    }

    @Override
    public int updateUser(User userOnbase) {
        return Db_Mysql_update.uaktualnijUseraWBazie(con, userOnbase);

    }

    @Override
    public int setUser(User userToBase) {
        return Db_Mysql_write.zapiszUseraDoBazy(con, userToBase);
    }

    @Override
    public String logUser(String login, String haslo) {

        boolean isLogged = false;
        String pesel = null;

        try {
            PreparedStatement pst = null;

            pst = con.prepareStatement("SELECT pesel,haslo,login from User where haslo =? and login = ?");
            pst.setString(1, Utility.toSHA1(haslo.getBytes()));
            pst.setString(2, login);
            ResultSet rs = pst.executeQuery();

            while (rs.next()) {
                isLogged = true;
                pesel = rs.getString("pesel");

            }
        } catch (Exception e) {
            System.err.println(e);
        }

        if (!isLogged) {
            return null;
        }

        return pesel;
    }

    /////////////////////////////// Pracownik
    @Override
    public Pracownik getPracownik(String pesel) {
        boolean isFounded = false;
        String login = "";
        String haslo = "";
        String imie = "";
        String nazwisko = "";
        String NIP = "";
        String telefon = "";
        String adres = "";
        String dataWygasnieciaUmowy = "";
        String rodzajUmowy = "";
        int idZespol = 0;
        int idZlecenie = 0;

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("SELECT * FROM Pracownik NATURAL JOIN User where User.Pesel= ?");
            pst.setString(1, pesel);
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                isFounded = true;
                //pobieranie po nazwach kolumn
                haslo = rs.getString("haslo");
                login = rs.getString("login");
                imie = rs.getString("imie");
                nazwisko = rs.getString("nazwisko");
                NIP = rs.getString("NIP");
                telefon = rs.getString("telefon");
                adres = rs.getString("adres");
                dataWygasnieciaUmowy = rs.getString("dataWygasnieciaUmowy");
                idZlecenie = rs.getInt("idZlecenie");
                rodzajUmowy = rs.getString("rodzajUmowy");
                idZespol = rs.getInt("idZespol");

            }
        } catch (Exception e) {
            System.err.println(e);
        }
        if (!isFounded) {
            return null;
        }

        Pracownik stworzonyPracownik;
        //stworzonyPracownik = new Pracownik(pesel, imie, nazwisko);
        stworzonyPracownik = new Pracownik(pesel, haslo, login, imie, nazwisko, NIP,
                telefon, adres, dataWygasnieciaUmowy, idZlecenie, rodzajUmowy, idZespol);

        stworzonyPracownik.setListaKategoria(getKategoriaListViaPesel(pesel));
        return stworzonyPracownik;
    }

    @Override
    public List<String> getPracownikPeselList() {

        List<String> listaPeseliPracownika = new ArrayList<String>();
        String pesel = "";

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select pesel from Pracownik");
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                pesel = rs.getString("pesel");
                listaPeseliPracownika.add(pesel);
            }
        } catch (Exception e) {
            System.err.println(e);
        }

        return listaPeseliPracownika;
    }

    @Override
    public List<Pracownik> getPracownikList() {

        List<Pracownik> pracownikList = new ArrayList<Pracownik>();
        List<String> listaPeseliPracownikow = db.getPracownikPeselList();

        for (String peselPracownikDoPobrania : listaPeseliPracownikow) {
            pracownikList.add(getPracownik(peselPracownikDoPobrania));
        }

        return pracownikList;
    }

    @Override
    public int setPracownik(Pracownik pracownikToBase) {
        return Db_Mysql_write.zapiszPracownikaDoBazy(con, pracownikToBase);
    }

    @Override
    public int updatePracownik(Pracownik pracownikOnBase) {
        return Db_Mysql_update.uaktualnijPracownikaWBazie(con, pracownikOnBase);

    }

    //////////////////////////////////////Ksiegowa
    @Override
    public Ksiegowa getKsiegowa(String pesel) {

        boolean isFounded = false;
        String login = "";
        String haslo = "";
        String imie = "";
        String nazwisko = "";
        String NIP = "";
        String telefon = "";
        String adres = "";
        String dataWygasnieciaUmowy = "";
        String certyfikat = "";
        String szkolenia = "";
        String uprawnienia = "";
        int idZlecenia = 0;

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("SELECT * FROM Ksiegowa NATURAL JOIN User where User.Pesel= ? ");
            pst.setString(1, pesel);
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                isFounded = true;
                //pobieranie po nazwach kolumn
                haslo = rs.getString("haslo");
                login = rs.getString("login");
                imie = rs.getString("imie");
                nazwisko = rs.getString("nazwisko");
                NIP = rs.getString("NIP");
                telefon = rs.getString("telefon");
                adres = rs.getString("adres");
                dataWygasnieciaUmowy = rs.getString("dataWygasnieciaUmowy");
                idZlecenia = rs.getInt("idZlecenie");
                certyfikat = rs.getString("certyfikat");
                szkolenia = rs.getString("szkolenia");
                uprawnienia = rs.getString("uprawnienia");

            }
        } catch (Exception e) {
            System.err.println(e);
        }
        if (!isFounded) {
            return null;
        }

        Ksiegowa stworzonaKsiegowa;
        stworzonaKsiegowa = new Ksiegowa(pesel, haslo, login, imie, nazwisko, NIP, telefon, adres, dataWygasnieciaUmowy, idZlecenia, certyfikat, szkolenia, uprawnienia);
        return stworzonaKsiegowa;

    }

    @Override
    public List<String> getKsiegowaPeselList() {

        List<String> listaPeseliKsiegowa = new ArrayList<String>();
        String pesel = "";
        System.out.print("pobieranie peseli");
        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select pesel from Ksiegowa");
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                pesel = rs.getString("pesel");
                System.out.print(" Pesel: " + pesel);
                listaPeseliKsiegowa.add(pesel);
            }
        } catch (Exception e) {
            System.err.println(e);
        }

        return listaPeseliKsiegowa;

    }

    @Override
    public List<Ksiegowa> getKsiegowaList() {

        List<Ksiegowa> ksiegowaList = new ArrayList<Ksiegowa>();
        List<String> listaPeseliKsiegowych = db.getKsiegowaPeselList();

        for (String peselKsiegowaDoPobrania : listaPeseliKsiegowych) {
            ksiegowaList.add(getKsiegowa(peselKsiegowaDoPobrania));
        }

        return ksiegowaList;
    }

    @Override
    public int setKsiegowa(Ksiegowa ksiegowaToBase) {
        return Db_Mysql_write.zapiszKiegowaDoBazy(con, ksiegowaToBase);
    }

    @Override
    public int updateKsiegowa(Ksiegowa ksiegowaOnBase) {
        return Db_Mysql_update.uaktualnijKsiegowaWBazie(con, ksiegowaOnBase);
    }

    ///////////////////////////////Dyrektor
    @Override
    public Dyrektor getDyrektor(String pesel) {

        boolean isFounded = false;
        String login = "";
        String haslo = "";
        String imie = "";
        String nazwisko = "";
        String NIP = "";
        String telefon = "";
        String adres = "";
        String dataWygasnieciaUmowy = "";
        String stanowisko = "";
        String obowiazki = "";
        String wyksztalcenie = "";
        int idZlecenia = 0;

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("SELECT * FROM Dyrektor NATURAL JOIN User where User.Pesel= ? ");
            pst.setString(1, pesel);
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                isFounded = true;
                //pobieranie po nazwach kolumn
                haslo = rs.getString("haslo");
                login = rs.getString("login");
                imie = rs.getString("imie");
                nazwisko = rs.getString("nazwisko");
                NIP = rs.getString("NIP");
                telefon = rs.getString("telefon");
                adres = rs.getString("adres");
                dataWygasnieciaUmowy = rs.getString("dataWygasnieciaUmowy");
                idZlecenia = rs.getInt("idZlecenie");
                stanowisko = rs.getString("stanowisko");
                obowiazki = rs.getString("obowiazki");
                wyksztalcenie = rs.getString("wyksztalcenie");

                //wyswietl
                /*System.out.println(haslo);
                 System.out.println(login);
                 System.out.println(imie);
                 System.out.println(nazwisko);
                 System.out.println(stanowisko);
                 System.out.println(obowiazki);
                 System.out.println(wyksztalcenie);*/
            }
        } catch (Exception e) {
            System.err.println(e);
        }
        if (!isFounded) {
            return null;
        }

        Dyrektor stworzonyDyrektor;
        stworzonyDyrektor = new Dyrektor(pesel, haslo, login, imie, nazwisko, NIP, telefon, adres, dataWygasnieciaUmowy, idZlecenia, stanowisko, obowiazki, wyksztalcenie);
        return stworzonyDyrektor;
    }

    @Override
    public List<String> getDyrektorPeselList() {

        List<String> listaPeseliDyrektorow = new ArrayList<String>();
        String pesel = "";
        System.out.print("pobieranie peseli");
        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select pesel from Dyrektor");
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                pesel = rs.getString("pesel");
                System.out.print(" Pesel: " + pesel);
                listaPeseliDyrektorow.add(pesel);
            }
        } catch (Exception e) {
            System.err.println(e);
        }
        return listaPeseliDyrektorow;
    }

    @Override
    public List<Dyrektor> getDyrektorList() {

        List<Dyrektor> dyrektorList = new ArrayList<Dyrektor>();
        List<String> listaPeseliDyrektorow = db.getDyrektorPeselList();

        for (String peselDyrektorDoPobrania : listaPeseliDyrektorow) {
            dyrektorList.add(getDyrektor(peselDyrektorDoPobrania));
        }

        return dyrektorList;
    }

    @Override
    public int setDyrektor(Dyrektor dyrektorToBase) {
        return Db_Mysql_write.zapiszDyrektoraDoBazy(con, dyrektorToBase);
    }

    @Override
    public int updateDyrektor(Dyrektor dyrektorOnBase) {
        return Db_Mysql_update.uaktualnijDyrektoraWBazie(con, dyrektorOnBase);
    }

    ///////////////////////////////////Klient
    @Override
    public Klient getKlient(int id) {

        boolean isFounded = false;
        String imie = null;
        String nazwisko = null;
        String nazwa = null;
        String miasto = null;
        String telefon = null;
        String typKlienta = null;

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select * from Klient where id= ? ");
            pst.setInt(1, id);
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                isFounded = true;
                //pobieranie po nazwach kolumn
                id = rs.getInt("id");
                imie = rs.getString("imie");
                nazwisko = rs.getString("nazwisko");
                nazwa = rs.getString("nazwa");
                miasto = rs.getString("miasto");
                telefon = rs.getString("telefon");
                typKlienta = rs.getString("typKlienta");

            }
        } catch (Exception e) {
            System.err.println(e);
        }
        if (!isFounded) {
            return null;
        }

        Klient stworzonyKlient;
        stworzonyKlient = new Klient(id, imie, nazwisko, nazwa, miasto, telefon, typKlienta);
        return stworzonyKlient;
    }

    @Override
    public List<Integer> getKlientIdList() {

        List<Integer> listaIdKlient = new ArrayList<Integer>();
        int id = 0;

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select id from Klient ORDER BY id");
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                id = rs.getInt("id");
                listaIdKlient.add(id);
            }
        } catch (Exception e) {
            System.err.println(e);
        }

        return listaIdKlient;
    }

    @Override
    public List<Klient> getKlientList() {

        List<Klient> klientList = new ArrayList<Klient>();
        List<Integer> listaidKlientow = db.getKlientIdList();

        for (Integer idKlientDoPobrania : listaidKlientow) {
            klientList.add(getKlient(idKlientDoPobrania));
        }

        return klientList;
    }

    @Override
    public int setKlient(Klient klientToBase) {
        return Db_Mysql_write.zapiszKlientaDoBazy(con, klientToBase);
    }

    @Override
    public int updateKlient(Klient klientOnBase) {
        return Db_Mysql_update.uaktualnijKlientaWBazie(con, klientOnBase);
    }

    @Override
    public int setKategoria(Kategoria kategoriaToBase) {
        return Db_Mysql_write.zapiszKategoriaDoBazy(con, kategoriaToBase);
    }

    @Override
    public int setSprzet(Sprzet sprzetToBase) {
        return Db_Mysql_write.zapiszSprzetDoBazy(con, sprzetToBase);
    }

    @Override
    public Zlecenie getZlecenie(int id) {

        boolean isFounded = false;

        String nazwaZlecenia = "";
        String opis = "";
        Date dataRozpoczecia = null;
        Date dataZakonczenia = null;
        BigDecimal doZaplaty = new BigDecimal(0.00);
        BigDecimal pobrano = new BigDecimal(0.00);
        Date dataPlatnosci = null;
        int idKlient = 0;

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("Select * from Zlecenie where id =?");
            pst.setInt(1, id);
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                isFounded = true;
                //pobieranie po nazwach kolumn
                id = rs.getInt("id");
                nazwaZlecenia = rs.getString("nazwaZlecenia");
                opis = rs.getString("opis");
                dataRozpoczecia = rs.getDate("dataRozpoczecia");
                dataZakonczenia = rs.getDate("dataZakonczenia");
                doZaplaty = rs.getBigDecimal("doZaplaty");
                pobrano = rs.getBigDecimal("pobrano");
                dataPlatnosci = rs.getDate("dataPlatnosci");
                idKlient = rs.getInt("idKlient");

            }
        } catch (Exception e) {
            System.err.println(e);
        }
        if (!isFounded) {
            return null;
        }

        Zlecenie stworzoneZlecenie;
        stworzoneZlecenie = new Zlecenie(id, nazwaZlecenia, opis, dataRozpoczecia, dataZakonczenia, doZaplaty, pobrano, dataPlatnosci, idKlient);
        return stworzoneZlecenie;
    }

    @Override
    public List<Zlecenie> getZlecenieList() {

        List<Zlecenie> zlecenieList = new ArrayList<Zlecenie>();
        List<Integer> listaIdZlecenie = db.getZlecenieIdList();

        for (Integer idZleceniaDoPobrania : listaIdZlecenie) {
            zlecenieList.add(getZlecenie(idZleceniaDoPobrania));
        }

        return zlecenieList;
    }

    @Override
    public List<Integer> getZlecenieIdList() {
        List<Integer> listaIdZlecenie = new ArrayList<Integer>();
        int id = 0;

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select id from Zlecenie ORDER BY id");
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                id = rs.getInt("id");
                listaIdZlecenie.add(id);
            }
        } catch (Exception e) {
            System.err.println(e);
        }

        return listaIdZlecenie;
    }

    @Override
    public boolean isLoginFree(String login) {
        boolean wynik = false;
        try (PreparedStatement pst = con.prepareStatement("select login from User where login = ?")) {
            pst.setString(1, login);
            try (ResultSet rs = pst.executeQuery()) {
                wynik = !rs.first();
            } catch (SQLException e) {
                System.err.println(e);
            }
        } catch (SQLException e) {
            System.err.println(e);
        }
        return wynik;
    }

    @Override
    public List<Sprzet> getSprzetList() {

        List<Sprzet> sprzetList = new ArrayList<Sprzet>();
        List<Integer> listaidSprzetu = db.getSprzetIdList();

        for (Integer idSprzetDoPobrania : listaidSprzetu) {
            sprzetList.add(getSprzet(idSprzetDoPobrania));
        }

        return sprzetList;
    }

    @Override
    public List<Integer> getSprzetIdList() {

        List<Integer> listaIdSprzet = new ArrayList<Integer>();
        int id = 0;

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select id from Sprzet ORDER BY id");
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                id = rs.getInt("id");
                listaIdSprzet.add(id);
            }
        } catch (Exception e) {
            System.err.println(e);
        }

        return listaIdSprzet;
    }

    @Override
    public Sprzet getSprzet(int id) {

        boolean isFounded = false;
        String nazwa = "";
        int ilosc = 0;
        String opis = "";
        String stanZgloszenia = "";
        String stanNaprawy = "";
        String pesel = "";

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select * from Sprzet where id= ? ");
            pst.setInt(1, id);
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                isFounded = true;
                //pobieranie po nazwach kolumn
                id = rs.getInt("id");
                nazwa = rs.getString("nazwa");
                ilosc = rs.getInt("ilosc");
                opis = rs.getString("opis");
                stanZgloszenia = rs.getString("stanZgloszenia");
                stanNaprawy = rs.getString("stanNaprawy");
                pesel = rs.getString("pesel");

            }
        } catch (Exception e) {
            System.err.println(e);
        }
        if (!isFounded) {
            return null;
        }

        Sprzet stworzonySprzet;
        stworzonySprzet = new Sprzet(id, nazwa, ilosc, opis, stanZgloszenia, stanNaprawy, pesel);
        return stworzonySprzet;
    }

    @Override
    public Kategoria getKategoria(int id) {

        boolean isFounded = false;
        String nazwa = "";
        String dataWaznosci = "";
        String pesel = "";

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select * from Kategoria where id= ? ");
            pst.setInt(1, id);
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                isFounded = true;
                //pobieranie po nazwach kolumn
                id = rs.getInt("id");
                nazwa = rs.getString("nazwa");
                dataWaznosci = rs.getString("dataWaznosci");
                pesel = rs.getString("pesel");

            }
        } catch (Exception e) {
            System.err.println(e);
        }
        if (!isFounded) {
            return null;
        }

        Kategoria stworzonaKategoria;
        stworzonaKategoria = new Kategoria(id, nazwa, dataWaznosci, getPracownik(pesel));
        return stworzonaKategoria;
    }

    @Override
    public Premia getPremia(int id) {

        boolean isFounded = false;
        String nazwaPracy = "";
        String suma = "";
        String powod = "";
        String decyzjaDyrektora = "";
        String rozpatrzenie = "";
        String pesel = "";

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select * from Premia where id= ? ");
            pst.setInt(1, id);
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                isFounded = true;
                //pobieranie po nazwach kolumn
                id = rs.getInt("id");
                nazwaPracy = rs.getString("nazwaPracy");
                suma = rs.getString("suma");
                powod = rs.getString("powod");
                decyzjaDyrektora = rs.getString("decyzjaDyrektora");
                rozpatrzenie = rs.getString("rozpatrzenie");
                pesel = rs.getString("pesel");

            }
        } catch (Exception e) {
            System.err.println(e);
        }
        if (!isFounded) {
            return null;
        }

        Premia stworzonaPremia;
        stworzonaPremia = new Premia(id, nazwaPracy, suma, powod, decyzjaDyrektora, rozpatrzenie, pesel);
        return stworzonaPremia;
    }

    @Override
    public List<Premia> getPremiaList() {
        List<Premia> premiaList = new ArrayList<Premia>();
        List<Integer> listaIdPremia = db.getPremiaIdList();

        for (Integer idPremiaDoPobrania : listaIdPremia) {
            premiaList.add(getPremia(idPremiaDoPobrania));
        }
        return premiaList;
    }

    @Override
    public List<Integer> getPremiaIdList() {

        List<Integer> listaIdPremia = new ArrayList<Integer>();
        int id = 0;
        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select id from Premia ORDER BY id");
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                id = rs.getInt("id");
                listaIdPremia.add(id);
            }
        } catch (Exception e) {
            System.err.println(e);
        }
        return listaIdPremia;
    }

    /*
     @Override
     public int setIdNowejAwarii() {
     return Db_Mysql_write.okreslIdNowejAwarii(con);
     }

     @Override
     public int setIdNowejKategorii() {
     return Db_Mysql_write.okreslIdNowejKategorii(con);
     }
     */
    @Override
    public StatusZlecenia getStatusZlecenia(int id) {

        boolean isFounded = false;
        Date dataWpisu = null;
        String opis = "";
        String statusZlecenia = "";
        int idZlecenie = 1;

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("Select * from StatusZlecenia where id =?");
            pst.setInt(1, id);
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                isFounded = true;
                //pobieranie po nazwach kolumn
                id = rs.getInt("id");
                dataWpisu = rs.getDate("dataWpisu");
                opis = rs.getString("opis");
                statusZlecenia = rs.getString("statusZlecenia");
                idZlecenie = rs.getInt("idZlecenie");

            }
        } catch (Exception e) {
            System.err.println(e);
        }
        if (!isFounded) {
            return null;
        }

        StatusZlecenia stworzonyStatusZlecenia;
        stworzonyStatusZlecenia = new StatusZlecenia(id, dataWpisu, opis, statusZlecenia, idZlecenie);
        System.out.println(stworzonyStatusZlecenia);
        return stworzonyStatusZlecenia;
    }

    @Override
    public int setStatusZlecenia(StatusZlecenia status) {
        return Db_Mysql_write.zapiszStatusZleceniaDoBazy(con, status);
    }

    @Override
    public List<StatusZlecenia> getStatusListViaZlecenie() {
        List<StatusZlecenia> statusZleceniaList = new ArrayList<StatusZlecenia>();
        List<Integer> listaIdZlecenie = db.getZlecenieIdList();

        for (Integer idZleceniaDoPobrania : listaIdZlecenie) {
            statusZleceniaList.add(getStatusZlecenia(idZleceniaDoPobrania));
        }

        return statusZleceniaList;
    }

    @Override
    public List<User> getUserListViaZlecenie() {
        List<User> userZlecenieList = new ArrayList<User>();
        List<Integer> listaIdZlecenie = db.getZlecenieIdList();

        for (Integer idZleceniaDoPobrania : listaIdZlecenie) {
            userZlecenieList.add(getUseridZlecenie(idZleceniaDoPobrania));
        }

        return userZlecenieList;
    }

    @Override
    public User getUseridZlecenie(int idZlecenie) {
        boolean isFounded = false;
        String pesel = "";
        String login = "";
        String haslo = "";
        String imie = "";
        String nazwisko = "";
        String NIP = "";
        String telefon = "";
        String adres = "";

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select * from User where idZlecenie= ? ");
            pst.setInt(1, idZlecenie);
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                isFounded = true;
                //pobieranie po nazwach kolumn
                pesel = rs.getString("pesel");
                haslo = rs.getString("haslo");
                login = rs.getString("login");
                imie = rs.getString("imie");
                nazwisko = rs.getString("nazwisko");
                NIP = rs.getString("NIP");
                telefon = rs.getString("telefon");
                adres = rs.getString("adres");
                //idZlecenie = rs.getInt("idZlecenie");

            }
        } catch (Exception e) {
            System.err.println(e);
        }

        if (!isFounded) {
            return null;
        }

        User stworzonyUseridZlecenie;
        stworzonyUseridZlecenie = new User(pesel, haslo, login, imie, nazwisko, NIP, telefon, adres, idZlecenie);
        return stworzonyUseridZlecenie;
    }

    @Override
    public List<Zlecenie> getZlecenieListViaKlient() {

        List<Zlecenie> klientZlecenieList = new ArrayList<Zlecenie>();
        List<Integer> listaidKlientow = db.getKlientIdList();

        for (Integer idKlientDoPobrania : listaidKlientow) {
            klientZlecenieList.add(getZlecenie(idKlientDoPobrania));
        }

        return klientZlecenieList;
    }

    @Override
    public List<Kategoria> getKategoriaList() {
        List<Kategoria> kategoriaList = new ArrayList<Kategoria>();
        List<Integer> listaIdKategoria = db.getKategoriaIdList();

        for (Integer idKategoriaDoPobrania : listaIdKategoria) {
            kategoriaList.add(getKategoria(idKategoriaDoPobrania));
        }

        return kategoriaList;
    }

    @Override
    public List<Integer> getKategoriaIdList() {

        List<Integer> listaIdKategoria = new ArrayList<Integer>();
        int id = 0;

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select id from Kategoria ORDER BY id");
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                id = rs.getInt("id");
                listaIdKategoria.add(id);
            }
        } catch (Exception e) {
            System.err.println(e);
        }

        return listaIdKategoria;
    }

    @Override
    public int setPremia(Premia premiaToBase) {
        return Db_Mysql_write.zapiszPremieDoBazy(con, premiaToBase);
    }

    @Override
    public List<Kategoria> getKategoriaListViaPesel(String pesel) {

        List<Kategoria> kategoriaListViaPesel = new ArrayList<Kategoria>();
        int id = -1;
        String nazwa = "";
        String dataWaznosci = "";

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select * from Kategoria where pesel = ?");
            pst.setString(1, pesel);
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                id = rs.getInt("id");
                nazwa = rs.getString("nazwa");
                dataWaznosci = rs.getString("dataWaznosci");
                Kategoria kat = new Kategoria(id, nazwa, dataWaznosci);
                kategoriaListViaPesel.add(kat);
            }
        } catch (Exception e) {
            System.err.println(e);
        }

        return kategoriaListViaPesel;
    }

    @Override
    public int updatePremia_rozlicz(int id) {

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("Update Premia set rozpatrzenie = ? where id = ?");
            pst.setString(1, "2");      //rozliczone
            pst.setInt(2, id);
            int i = pst.executeUpdate();
            System.out.println(i + " rekordow zmienionych w tabeli Premia");

        } catch (Exception e) {
            System.err.println(e);
            return 1; // 1- niepowodzenie
        }
        return 0; //wszystko ok
    }

    @Override
    public int updatePremia_odrzuc(int id) {

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("Update Premia set rozpatrzenie = ? where id = ?");
            pst.setString(1, "-1");      //rozliczone
            pst.setInt(2, id);
            int i = pst.executeUpdate();
            System.out.println(i + " rekordow zmienionych w tabeli Premia");

        } catch (Exception e) {
            System.err.println(e);
            return 1; // 1- niepowodzenie
        }
        return 0; //wszystko ok
    }

    @Override
    public int updatePremia_przyznaj(int id) {

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("Update Premia set rozpatrzenie = ? where id = ?");
            pst.setString(1, "1");      //rozliczone
            pst.setInt(2, id);
            int i = pst.executeUpdate();
            System.out.println(i + " rekordow zmienionych w tabeli Premia");

        } catch (Exception e) {
            System.err.println(e);
            return 1; // 1- niepowodzenie
        }
        return 0; //wszystko ok
    }

    @Override
    public List<Premia> getPremiaListViaRozpatrzenie(String rozpatrzenie) {

        List<Premia> premiaListViaRozpatrzenie = new ArrayList<Premia>();
        int id = -1;
        String nazwaPracy = "";
        String suma = "";
        String powod = "";
        String decyzjaDyrektora = "";
        String pesel = "";

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select * from Premia where rozpatrzenie = ?");
            pst.setString(1, rozpatrzenie);
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                id = rs.getInt("id");
                nazwaPracy = rs.getString("nazwaPracy");
                suma = rs.getString("suma");
                powod = rs.getString("powod");
                decyzjaDyrektora = rs.getString("decyzjaDyrektora");
                pesel = rs.getString("pesel");
                Premia prem = new Premia(id, nazwaPracy, suma, powod, decyzjaDyrektora, rozpatrzenie, pesel);
                premiaListViaRozpatrzenie.add(prem);
            }
        } catch (Exception e) {
            System.err.println(e);
        }

        return premiaListViaRozpatrzenie;
    }

    @Override
    public int updatePremia_decyzjaDyrektora(int id, String decyzja) {

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("Update Premia set decyzjaDyrektora = ? where id = ?");

            pst.setString(1, decyzja);      //rozliczone
            pst.setInt(2, id);
            int i = pst.executeUpdate();
            System.out.println(i + " rekordow zmienionych w tabeli Premia");

        } catch (Exception e) {
            System.err.println(e);
            return 1; // 1- niepowodzenie
        }
        return 0; //wszystko ok
    }

    @Override
    public int setZlecenie(Zlecenie zlecenieToBase) {
        return Db_Mysql_write.zapiszZlecenieDoBazy(con, zlecenieToBase);
    }

    @Override
    public List<Integer> getZespolIdList() {

        List<Integer> listaIdZespol = new ArrayList<Integer>();
        int id = 0;

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select id from Zespol ORDER BY id");
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                id = rs.getInt("id");
                listaIdZespol.add(id);
            }
        } catch (Exception e) {
            System.err.println(e);
        }

        return listaIdZespol;
    }

    @Override
    public int deleteUser(String pesel) {
        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("DELETE FROM User where pesel = ?");
            pst.setString(1, pesel);      //rozliczone
            int i = pst.executeUpdate();
            System.out.println(i + " rekordow zmienionych w tabeli User");

        } catch (Exception e) {
            System.err.println(e);
            return 1; // 1- niepowodzenie
        }
        return 0; //wszystko ok
    }
    /*
     @Override
     public int updateSprzet(Sprzet sprzetOnBase) {
     return Db_Mysql_update.uaktualnijSprzetWBazie(con, sprzetOnBase);
     }*/

    @Override
    public int updateSprzet_stanZgloszenia(int id) {

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("Update Sprzet set stanZgloszenia = ? where id = ?");
            pst.setString(1, "1");      //rozliczone
            pst.setInt(2, id);
            int i = pst.executeUpdate();
            System.out.println(i + " rekordow zmienionych w tabeli Sprzet");

        } catch (Exception e) {
            System.err.println(e);
            return 1; // 1- niepowodzenie
        }
        return 0; //wszystko ok
    }

    @Override
    public int updateZlecenie(Zlecenie zlecenieDoUpdatu) {
        return Db_Mysql_update.uaktualnijZlecenieWBazie(con, zlecenieDoUpdatu);
    }

    @Override
    public int rozliczZlecenie(int idZlecenia) {
        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("DELETE FROM Zlecenie where id = ?");
            pst.setInt(1, idZlecenia);      //rozliczone
            int i = pst.executeUpdate();
            System.out.println(i + " rekordow zmienionych w tabeli Zlecenie");

        } catch (Exception e) {
            System.err.println(e);
            return 1; // 1- niepowodzenie
        }
        return 0; //wszystko ok
    }

    @Override
    public Zespol getZespol(int id) {

        boolean isFounded = false;
        String nazwa = null;

        try {
            PreparedStatement pst = null;
            pst = con.prepareStatement("select * from Zespol where id= ? ");
            pst.setInt(1, id);
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                isFounded = true;
                //pobieranie po nazwach kolumn
                id = rs.getInt("id");
                nazwa = rs.getString("nazwa");

            }
        } catch (Exception e) {
            System.err.println(e);
        }
        if (!isFounded) {
            return null;
        }

        Zespol stworzonyZespol;
        stworzonyZespol = new Zespol(id, nazwa);
        return stworzonyZespol;
    }

}
